// 导入 Vue 的响应式 API，包括 ref 和 computed
import {ref, computed} from 'vue'
// 导入 Pinia 的 defineStore 方法，用于定义状态管理 store
import {defineStore} from 'pinia'
// 导入封装的请求模块，用于发送 HTTP 请求
import requestUtil from '@/utils/request'
// 导入 User 类型定义，用于类型检查
import type {User, ApiResponse} from '@/types/user'
// 导入路由实例，用于重定向
import router from '@/router'

interface LoginForm {
    username: string  // 用户名
    password: string // 密码
}

interface RegisterForm {
    username: string
    password: string
    email?: string // 邮箱, 可选
    phonenumber?: string // 手机号, 可选
}

export const useUserStore = defineStore('user', () => {
    // 状态
    // 用户信息响应式变量，初始值为null
    const user = ref<User | null>(null)
    // 认证令牌响应式变量，从初始化时从localStorage中获取
    const token = ref<string | null>(null)

    // 初始化状态：从localStorage恢复 token
    const initializeState = () => {
        const savedToken = localStorage.getItem('token')
        if (savedToken) {
            token.value = savedToken
        }
    }

    // 立即初始化状态
    initializeState()

    // 计算属性，用于判断用户是否已登录（基于token是否存在）
    const isLoggedIn = computed(() => !!token.value)
    // 计算属性，用于判断用户是否已完全认证（既有token又有用户信息）
    const isAuthenticated = computed(() => !!token.value && !!user.value)

    /**
     * 用户登录函数
     * @param loginForm 包含用户名和密码的登录表单数据
     * @returns 返回登录结果对象，包含success状态和message信息
     */
    const login = async (loginForm: LoginForm) => {
        try {
            // 发送登录请求
            const response = await requestUtil.post('/api/user/login/', loginForm);
            const apiResponse = response.data as ApiResponse<{ token: string, user: User }>;

            // 处理API响应结果
            if (apiResponse.code === 200 && apiResponse.data) {
                // 解构获取JWT token和用户信息
                const {token: jwtToken, user: userInfo} = apiResponse.data;

                // 存储token和用户信息到响应式变量和本地存储
                token.value = jwtToken;
                user.value = userInfo;
                localStorage.setItem('token', jwtToken); // 保存token到本地存储
                return {success: true, message: apiResponse.message}; // 返回登录成功信息
            } else {
                return {success: false, message: apiResponse.message}; // 返回登录失败信息
            }
        } catch (error: any) {
            // 处理登录异常情况
            return {
                success: false,
                message: error.message || '登录失败，请稍后重试'
            };
        }
    };

    /**
     * 用户注册函数
     * @param registerForm - 注册表单数据，包含用户注册所需的信息
     * @returns Promise对象，包含注册结果信息，格式为{success: boolean, message: string}
     */
    const register = async (registerForm: RegisterForm) => {
        try {
            // console.log("registerForm:", registerForm)
            // 发送注册请求到服务器
            const response = await requestUtil.post('/api/user/register/', registerForm)
            const apiResponse = response.data as ApiResponse
            // 根据服务器返回的状态码判断注册是否成功
            if (apiResponse.code === 200) {
                // console.log("response:", apiResponse)
                return {success: true, message: apiResponse.message} // 返回注册成功信息
            } else {
                // console.log("response:", apiResponse)
                return {success: false, message: apiResponse.message}// 返回注册失败信息
            }
        } catch (error: any) {
            console.log("response_error:", error)
            // 处理注册过程中出现的异常情况
            return {
                success: false,
                message: error.message || '注册失败，请稍后重试'
            }
        }
    }

    // 清除认证信息
    const clearAuth = () => {
        localStorage.removeItem('token')
        user.value = null
        token.value = null
    }
    // 登出
    const logout = () => {
        if (token.value) {
            clearAuth() // 清除认证信息
            router.push('/login') // 重定向到登录页面
        }
    }

    /**
     * 获取用户信息
     * @returns Promise<User> 返回用户信息对象
     * @throws Error 当获取用户信息失败时抛出错误
     */
    const fetchUserInfo = async () => {
        try {
            // 发送请求获取用户信息
            const response = await requestUtil.get('/api/user/user_info/')
            const apiResponse = response.data as ApiResponse<User>

            console.log('获取用户信息response:', apiResponse)
            // 检查响应状态码和数据有效性
            if (apiResponse.code === 200 && apiResponse.data) {
                user.value = apiResponse.data // 更新store中的用户信息
                return apiResponse.data // 返回用户信息
            } else {
                throw new Error(apiResponse.message || '获取用户信息失败')
            }
        } catch (error: any) {
            // 处理获取用户信息过程中的错误
            console.error('获取用户信息失败:', error)
            throw error
        }
    }

    /**
     * 更新用户信息
     * @param userInfo - 部分用户信息字段
     * @returns Promise对象，包含更新结果信息
     */
    const updateUserInfo = async (userInfo: Partial<User>) => {
        try {
            // 为后端字段做映射与格式规范
            const payload: Record<string, any> = {
                ...userInfo,
            }
            // 将前端 phone 字段映射为后端 phonenumber
            if ((payload as any).phone && !(payload as any).phonenumber) {
                (payload as any).phonenumber = (payload as any).phone
                delete (payload as any).phone
            }
            // birthday 统一为 YYYY-MM-DD 字符串
            if (payload.birthday instanceof Date) {
                const year = payload.birthday.getFullYear()
                const month = String(payload.birthday.getMonth() + 1).padStart(2, '0')
                const day = String(payload.birthday.getDate()).padStart(2, '0')
                payload.birthday = `${year}-${month}-${day}`
            }

            // 发送更新用户信息的请求
            const response = await requestUtil.put('/api/user/user_info/', payload);
            const apiResponse = response.data as ApiResponse<User>;

            // 检查响应状态码和数据有效性
            if (apiResponse.code === 200 && apiResponse.data) {
                // 更新store中的用户信息
                user.value = {
                    ...apiResponse.data
                } as User;
                console.log('更新用户信息response:', apiResponse.data)
                return {
                    success: true,
                    message: apiResponse.message || '用户信息更新成功',
                    data: apiResponse.data
                };
            } else {
                return {
                    success: false,
                    message: apiResponse.message || '用户信息更新失败'
                };
            }
        } catch (error: any) {
            // 处理更新过程中出现的异常
            console.error('更新用户信息失败:', error);
            return {
                success: false,
                message: error.message || '更新失败，请稍后重试'
            };
        }
    };

    // 上传头像
    const uploadAvatar = async (file: File) => {
        try {
            const formData = new FormData()
            formData.append('avatar', file)

            const response = await requestUtil.fileUpload('/api/user/avatar_upload/', formData)
            const apiResponse = response.data as ApiResponse<{ avatar: string }>

            if (apiResponse.code === 200 && apiResponse.data) {
                // 更新用户头像
                if (user.value) {
                    user.value.avatar = apiResponse.data.avatar
                }
                return {success: true, message: apiResponse.message, avatar: apiResponse.data.avatar}
            } else {
                return {success: false, message: apiResponse.message}
            }
        } catch (error: any) {
            return {
                success: false,
                message: error.message || '头像上传失败，请稍后重试'
            }
        }
    }

    //修改密码
    const changePassword = async (oldPassword: string, newPassword: string) => {
        try {
            const response = await requestUtil.post('/api/user/change_password/', {
                old_password: oldPassword,
                new_password: newPassword
            })
            const apiResponse = response.data as ApiResponse<{ message: string }>

            if (apiResponse.code === 200) {
                return {success: true, message: apiResponse.message}
            } else {
                return {success: false, message: apiResponse.message}
            }
        } catch (error: any) {
            return {
                success: false,
                message: error.message || '修改密码失败，请稍后重试'
            }
        }
    }

    /**
     * 管理端：获取用户列表（含分页）
     */
    const getAdminUsers = async (params: any) => {
        const res = await requestUtil.get('/api/user/admin/users/', params)
        const data = res.data
        if (data && typeof data.count !== 'undefined') {
            return {
                count: data.count,
                results: (data.results && data.results.results) || []
            }
        }
        return {count: 0, results: []}
    }

    /**
     * 管理端：创建用户
     */
    const createAdminUser = async (payload: { username: string; password: string; role_key?: string; is_active?: boolean }) => {
        const res = await requestUtil.post('/api/user/admin/users/', payload)
        return res.data
    }

    /**
     * 管理端：更新用户
     */
    const updateAdminUser = async (userId: number, payload: { role_key?: string; is_active?: boolean; email?: string }) => {
        const res = await requestUtil.put(`/api/user/admin/users/${userId}/`, payload)
        return res.data
    }

    /**
     * 管理端：切换启用禁用
     */
    const toggleAdminUserStatus = async (userId: number) => {
        const res = await requestUtil.post(`/api/user/admin/users/${userId}/toggle_status/`)
        return res.data
    }

    /**
     * 管理端：重置密码为 123456
     */
    const resetAdminUserPassword = async (userId: number) => {
        const res = await requestUtil.post(`/api/user/admin/users/${userId}/reset_password/`)
        return res.data
    }

    /**
     * 管理端：删除用户
     */
    const deleteAdminUser = async (userId: number) => {
        const res = await requestUtil.del(`/api/user/admin/users/${userId}/`)
        return res.data
    }

    return {
        user, // 用户信息
        token, // 认证token
        isLoggedIn, // 用户是否已登录
        isAuthenticated, // 用户是否已认证
        initializeState, // 初始化状态函数
        login, // 登录函数
        register, // 注册函数
        logout, // 登出函数
        fetchUserInfo, // 获取用户信息函数
        clearAuth, // 清除认证信息函数
        updateUserInfo,  // 更新用户信息函数
        uploadAvatar, // 上传头像函数
        changePassword, // 修改密码函数
        // 管理端用户
        getAdminUsers,
        createAdminUser,
        updateAdminUser,
        toggleAdminUserStatus,
        resetAdminUserPassword,
        deleteAdminUser,
    }
})
